package models

import (
	"fmt"
	"log"
	"regexp"
	"strconv"
	"time"

	"github.com/google/uuid"
	"gorm.io/gorm"
)

// CarBrowserInfo 对外接口改造后返回的浏览器信息
type CarBrowserInfo struct {
	CarID           string    `json:"carID"` // ExternalBrowserID 转为字符串
	BrowserName     string    `json:"browserName"`
	BrowserType     string    `json:"browserType"`
	BrowserTargName string    `json:"browserTargName"`
	ExpirationTime  time.Time `json:"expirationTime"`
	IsPlus          int       `json:"isPlus"` // 默认 0
	Status          int       `json:"status"` // 默认 1
}

// ExternalBrowserInfo 对外接口返回的浏览器信息
type ExternalBrowserInfo struct {
	ExternalBrowserID int       `json:"externalBrowserId"`
	BrowserName       string    `json:"browserName"`
	BrowserType       string    `json:"browserType"`
	ExpirationTime    time.Time `json:"expirationTime"`
	Active            bool      `json:"active"`
}

// User 用户基本信息表
type User struct {
	ID         uuid.UUID `gorm:"type:char(36);primary_key"`
	CreatedAt  time.Time
	UpdatedAt  time.Time
	DeletedAt  gorm.DeletedAt `gorm:"index"`
	Username   string         `gorm:"size:100;index;not null"` // 普通索引，不是唯一索引
	WorkerName string         `gorm:"size:100;index;not null"` // 成员名称
	Active     bool           `gorm:"default:true;index"`
}

// BeforeCreate 创建前自动生成UUID
func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
	if u.ID == uuid.Nil {
		u.ID = uuid.New()
	}
	return
}

// Group 分组信息表
type Group struct {
	ID        uuid.UUID `gorm:"type:char(36);primary_key"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt gorm.DeletedAt `gorm:"index"`
	GroupID   int            `gorm:"not null;index"` // 外部系统的分组ID
	GroupName string         `gorm:"size:255;not null"`
	UserID    uuid.UUID      `gorm:"type:char(36);index;not null"` // 所属用户
	Active    bool           `gorm:"default:true;index"`
}

// BeforeCreate 创建前自动生成UUID
func (g *Group) BeforeCreate(tx *gorm.DB) (err error) {
	if g.ID == uuid.Nil {
		g.ID = uuid.New()
	}
	return
}

// Browser 浏览器信息表
type Browser struct {
	ID                uuid.UUID `gorm:"type:char(36);primary_key"`
	CreatedAt         time.Time
	UpdatedAt         time.Time
	DeletedAt         gorm.DeletedAt `gorm:"index"`
	GroupID           uuid.UUID      `gorm:"type:char(36);index;not null"` // 所属分组的UUID
	ExternalBrowserID int            `gorm:"index"`                        // 外部系统的浏览器ID，可能为空
	BrowserName       string         `gorm:"size:255;not null"`
	BrowserType       string         `gorm:"size:50;not null;index"`
	BrowserTargName   string         `gorm:"size:100;not null"`
	ExpirationTime    time.Time      `gorm:"not null;index"`
	Active            bool           `gorm:"default:true;index"`
}

// BeforeCreate 创建前自动生成UUID
func (b *Browser) BeforeCreate(tx *gorm.DB) (err error) {
	if b.ID == uuid.Nil {
		b.ID = uuid.New()
	}
	return
}

// UserBrowserComposite 用户-浏览器组合视图（非数据库表，仅用于API响应）
type UserBrowserComposite struct {
	UserID       uuid.UUID `json:"userId"`
	Username     string    `json:"username"`
	WorkerName   string    `json:"workerName"`
	BrowserTypes []string  `json:"browserTypes"`
	BrowserTags  []string  `json:"browserTags"`
	GroupIDs     []int     `json:"groupIds"`
	GroupNames   []string  `json:"groupNames"`
	IsActive     bool      `json:"isActive"`
}

// 判断用户的指定浏览器类型是否存在且有效
func UserBrowserExistsAndActive(username string, browserType string) (bool, *User, *Group, *Browser) {
	var user User
	var browser Browser

	// 首先查找用户
	if err := DB.Where("username = ? AND active = ?", username, true).First(&user).Error; err != nil {
		return false, nil, nil, nil
	}

	// 找到用户的分组
	var groups []Group
	if err := DB.Where("user_id = ? AND active = ?", user.ID, true).Find(&groups).Error; err != nil {
		return false, &user, nil, nil
	}

	// 如果没有找到分组，返回用户但没有分组和浏览器
	if len(groups) == 0 {
		return false, &user, nil, nil
	}

	// 提取所有分组ID
	var groupIDs []uuid.UUID
	for _, group := range groups {
		groupIDs = append(groupIDs, group.ID)
	}

	// 查找用户组中指定类型的浏览器
	// 查询条件：分组ID在用户的分组列表中，浏览器类型匹配，活跃且未过期
	result := DB.Where("group_id IN ? AND browser_type = ? AND active = ? AND expiration_time > ?",
		groupIDs, browserType, true, time.Now()).First(&browser)

	if result.RowsAffected > 0 {
		// 找到浏览器所属的分组
		var group Group
		DB.First(&group, "id = ?", browser.GroupID)
		return true, &user, &group, &browser
	}

	return false, &user, nil, nil
}

// 根据正则模式查找用户的浏览器
func FindUserBrowserByPattern(pattern string, browserType string) (bool, *User, *Group, *Browser) {
	var users []User
	// 先获取所有可能匹配的用户
	if err := DB.Where("active = ?", true).Find(&users).Error; err != nil {
		return false, nil, nil, nil
	}

	// 编译正则表达式
	re, err := regexp.Compile(pattern)
	if err != nil {
		return false, nil, nil, nil
	}

	// 遍历用户，检查用户名是否匹配模式
	for _, user := range users {
		if re.MatchString(user.Username) {
			// 找到用户的分组
			var groups []Group
			if err := DB.Where("user_id = ? AND active = ?", user.ID, true).Find(&groups).Error; err != nil {
				continue
			}

			// 如果没有找到分组，继续下一个用户
			if len(groups) == 0 {
				continue
			}

			// 提取所有分组ID
			var groupIDs []uuid.UUID
			for _, group := range groups {
				groupIDs = append(groupIDs, group.ID)
			}

			// 查找用户组中指定类型的浏览器
			var browser Browser
			result := DB.Where("group_id IN ? AND browser_type = ? AND active = ? AND expiration_time > ?",
				groupIDs, browserType, true, time.Now()).First(&browser)

			if result.RowsAffected > 0 {
				// 找到浏览器所属的分组
				var group Group
				DB.First(&group, "id = ?", browser.GroupID)
				return true, &user, &group, &browser
			}
		}
	}

	return false, nil, nil, nil
}

// 查找用户是否存在（不考虑浏览器类型）
func FindUserByUsername(username string) (bool, *User, []Group, []Browser) {
	var groups []Group
	var browsers []Browser
	// 只获取以username开头的用户，优化查询性能
	var user User
	if err := DB.Where("username = ? AND active = ?", username, true).First(&user).Error; err != nil {
		return false, nil, nil, nil
	}

	// 查找该用户的所有分组
	if err := DB.Where("user_id = ? AND active = ?", user.ID, true).Find(&groups).Error; err != nil {
		return true, &user, nil, nil
	}

	// 如果找到分组，查找所有分组下的浏览器
	if len(groups) > 0 {
		var groupIDs []uuid.UUID
		for _, group := range groups {
			groupIDs = append(groupIDs, group.ID)
		}

		// 查询所有分组下的活跃浏览器
		if err := DB.Where("group_id IN ? AND active = ?", groupIDs, true).Find(&browsers).Error; err != nil {
			return true, &user, groups, nil
		}

		return true, &user, groups, browsers
	}

	return true, &user, groups, nil
}

// 获取用户所有外部分组ID
func GetExternalGroupIDs(groups []Group) []int {
	uniqueGroupIDs := make(map[int]bool)
	for _, group := range groups {
		uniqueGroupIDs[group.GroupID] = true
	}

	var groupIDs []int
	for gid := range uniqueGroupIDs {
		groupIDs = append(groupIDs, gid)
	}

	return groupIDs
}

// 更新浏览器信息
func UpdateBrowser(browser *Browser) error {
	return DB.Save(browser).Error
}

// 创建用户（如果不存在）、分组（如果不存在）和浏览器
func CreateUserWithGroupAndBrowser(username string, workerName string, groupName string, externalGroupID int, browserName string, browserType string, baseBrowserTargName string, expirationTime time.Time) (*User, *Group, *Browser, error) {
	// 开始事务
	tx := DB.Begin()
	if tx.Error != nil {
		return nil, nil, nil, tx.Error
	}

	// 延迟提交或回滚
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 先查找用户是否存在
	var user User
	result := tx.Where("username = ? AND active = ?", username, true).First(&user)

	// 如果用户不存在，创建新用户
	if result.RowsAffected == 0 {
		user = User{
			Username:   username,
			WorkerName: workerName,
			Active:     true,
		}
		if err := tx.Create(&user).Error; err != nil {
			tx.Rollback()
			return nil, nil, nil, err
		}
	}

	// 查找此用户的指定外部分组ID是否存在
	var group Group
	result = tx.Where("user_id = ? AND group_id = ? AND active = ?", user.ID, externalGroupID, true).First(&group)

	// 如果分组不存在，创建新分组
	if result.RowsAffected == 0 {
		group = Group{
			GroupID:   externalGroupID,
			GroupName: groupName,
			UserID:    user.ID,
			Active:    true,
		}
		if err := tx.Create(&group).Error; err != nil {
			tx.Rollback()
			return nil, nil, nil, err
		}
	}

	// 创建新浏览器
	browser := Browser{
		GroupID:         group.ID,
		BrowserName:     browserName,
		BrowserType:     browserType,
		ExpirationTime:  expirationTime,
		BrowserTargName: baseBrowserTargName,
		Active:          true,
	}

	if err := tx.Create(&browser).Error; err != nil {
		tx.Rollback()
		return nil, nil, nil, err
	}

	// 提交事务
	if err := tx.Commit().Error; err != nil {
		return nil, nil, nil, err
	}

	return &user, &group, &browser, nil
}

// 获取用户列表（支持分页和过滤）
func GetUserList(page, pageSize int, usernameFilter, baseBrowserAccountFilter string) ([]UserBrowserComposite, int64, error) {
	var total int64

	// 构建基本查询
	query := DB.Model(&User{}).Where("users.active = ?", true)

	// 用户名过滤
	if usernameFilter != "" {
		query = query.Where("users.username LIKE ?", "%"+usernameFilter+"%")
	}

	// 如果有baseBrowserAccount过滤，需要连接表查询
	if baseBrowserAccountFilter != "" {
		// 修复JOIN语句，确保表名正确并使用引号包裹
		query = query.Joins("JOIN `groups` ON `users`.`id` = `groups`.`user_id`").
			Joins("JOIN `browsers` ON `groups`.`id` = `browsers`.`group_id`").
			Where("browsers.browser_type LIKE ? AND browsers.active = ? AND groups.active = ?",
				"%"+baseBrowserAccountFilter+"%", 1, 1)
	}

	// 计算总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 为避免反射错误，使用字符串切片而不是UUID切片
	var userIDStrs []string

	// 分页查询用户ID - 修复DISTINCT和ORDER BY不兼容的问题
	if baseBrowserAccountFilter != "" {
		// 对于需要去重的查询，使用子查询
		subQuery := DB.Table("users").
			Select("DISTINCT users.id").
			Joins("JOIN `groups` ON `users`.`id` = `groups`.`user_id`").
			Joins("JOIN `browsers` ON `groups`.`id` = `browsers`.`group_id`").
			Where("users.active = ? AND browsers.browser_type LIKE ? AND browsers.active = ? AND groups.active = ?",
				true, "%"+baseBrowserAccountFilter+"%", 1, 1)

		if err := DB.Table("(?) as u", subQuery).
			Select("u.id").
			Order("u.id DESC").
			Limit(pageSize).
			Offset((page-1)*pageSize).
			Pluck("u.id", &userIDStrs).Error; err != nil {
			return nil, 0, err
		}
	} else {
		// 对于不需要DISTINCT的普通查询，直接使用排序
		if err := query.Select("users.id").
			Order("users.created_at DESC").
			Limit(pageSize).
			Offset((page-1)*pageSize).
			Pluck("users.id", &userIDStrs).Error; err != nil {
			return nil, 0, err
		}
	}

	// 将字符串ID转换为UUID
	var userIDs []uuid.UUID
	for _, idStr := range userIDStrs {
		id, err := uuid.Parse(idStr)
		if err == nil {
			userIDs = append(userIDs, id)
		}
	}
	log.Printf("userIDs: %v", userIDs)
	// 获取详细信息并组装结果
	var composites []UserBrowserComposite
	for _, userID := range userIDs {
		var user User
		var groups []Group
		var browsers []Browser

		// 获取用户信息
		if err := DB.First(&user, "id = ?", userID).Error; err != nil {
			continue
		}

		// 获取该用户的所有分组
		if err := DB.Find(&groups, "user_id = ? AND active = ?", userID, true).Error; err != nil {
			continue
		}

		// 提取所有分组ID
		var groupIDs []uuid.UUID
		for _, group := range groups {
			groupIDs = append(groupIDs, group.ID)
		}

		// 获取所有分组的浏览器
		if len(groupIDs) > 0 {
			if err := DB.Find(&browsers, "group_id IN ? AND active = ?", groupIDs, true).Error; err != nil {
				continue
			}
		}

		// 组装数据
		browserTypes := make([]string, 0)
		browserTags := make([]string, 0)
		externalGroupIDs := make([]int, 0)
		groupNames := make([]string, 0)

		// 为避免重复，使用map记录已添加的信息
		typesMap := make(map[string]bool)
		groupIDMap := make(map[int]bool)
		groupNameMap := make(map[string]bool)
		tagsMap := make(map[string]bool)

		for _, browser := range browsers {
			if !typesMap[browser.BrowserType] {
				browserTypes = append(browserTypes, browser.BrowserType)
				typesMap[browser.BrowserType] = true
			}

			if !tagsMap[browser.BrowserTargName] {
				browserTags = append(browserTags, browser.BrowserTargName)
				tagsMap[browser.BrowserTargName] = true
			}

			// 查找浏览器所属的分组
			for _, group := range groups {
				if group.ID == browser.GroupID {
					if !groupIDMap[group.GroupID] {
						externalGroupIDs = append(externalGroupIDs, group.GroupID)
						groupIDMap[group.GroupID] = true
					}

					if !groupNameMap[group.GroupName] {
						groupNames = append(groupNames, group.GroupName)
						groupNameMap[group.GroupName] = true
					}
					break
				}
			}
		}

		composite := UserBrowserComposite{
			UserID:       user.ID,
			Username:     user.Username,
			WorkerName:   user.WorkerName,
			BrowserTypes: browserTypes,
			BrowserTags:  browserTags,
			GroupIDs:     externalGroupIDs,
			GroupNames:   groupNames,
			IsActive:     user.Active,
		}

		composites = append(composites, composite)
	}

	return composites, total, nil
}

// 根据ID获取用户完整信息
func GetUserByID(id uuid.UUID) (*User, []Group, []Browser, error) {
	var user User
	var groups []Group
	var browsers []Browser

	if err := DB.First(&user, "id = ?", id).Error; err != nil {
		return nil, nil, nil, err
	}

	if err := DB.Find(&groups, "user_id = ? AND active = ?", id, true).Error; err != nil {
		return &user, nil, nil, err
	}

	// 提取所有分组ID
	var groupIDs []uuid.UUID
	for _, group := range groups {
		groupIDs = append(groupIDs, group.ID)
	}

	// 查询所有分组下的活跃浏览器
	if len(groupIDs) > 0 {
		if err := DB.Find(&browsers, "group_id IN ? AND active = ?", groupIDs, true).Error; err != nil {
			return &user, groups, nil, err
		}
	}

	return &user, groups, browsers, nil
}

// 删除用户及其所有资源
func DeleteUser(id uuid.UUID) error {
	// 开始事务
	tx := DB.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	// 先获取用户的所有分组
	var groups []Group
	if err := tx.Find(&groups, "user_id = ? AND active = ?", id, true).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 提取所有分组ID
	var groupIDs []uuid.UUID
	for _, group := range groups {
		groupIDs = append(groupIDs, group.ID)
	}

	// 软删除所有分组下的浏览器
	if len(groupIDs) > 0 {
		if err := tx.Model(&Browser{}).Where("group_id IN ?", groupIDs).Update("active", false).Error; err != nil {
			tx.Rollback()
			return err
		}
	}

	// 软删除所有分组
	if err := tx.Model(&Group{}).Where("user_id = ?", id).Update("active", false).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 软删除用户
	if err := tx.Model(&User{}).Where("id = ?", id).Update("active", false).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 提交事务
	return tx.Commit().Error
}

// 更新用户及关联资源状态（启用/禁用）
func UpdateUserStatus(id uuid.UUID, active bool) error {
	// 开始事务
	tx := DB.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	// 更新用户状态
	if err := tx.Model(&User{}).Where("id = ?", id).Update("active", active).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 获取用户的所有分组
	var groups []Group
	if err := tx.Find(&groups, "user_id = ?", id).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 更新所有分组状态
	if err := tx.Model(&Group{}).Where("user_id = ?", id).Update("active", active).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 提取所有分组ID
	var groupIDs []uuid.UUID
	for _, group := range groups {
		groupIDs = append(groupIDs, group.ID)
	}

	// 更新所有分组下的浏览器状态
	if len(groupIDs) > 0 {
		if err := tx.Model(&Browser{}).Where("group_id IN ?", groupIDs).Update("active", active).Error; err != nil {
			tx.Rollback()
			return err
		}
	}

	// 提交事务
	return tx.Commit().Error
}

// 更新指定浏览器的过期时间
func UpdateBrowserExpiration(browserID uuid.UUID, expirationTime time.Time) error {
	return DB.Model(&Browser{}).Where("id = ?", browserID).
		Update("expiration_time", expirationTime).Error
}

// 查找所有过期浏览器
func FindExpiredBrowsers() ([]Browser, error) {
	var browsers []Browser
	result := DB.Where("active = ? OR expiration_time < ?", false, time.Now()).Find(&browsers)
	return browsers, result.Error
}

// 获取用户的所有浏览器类型组合
func GetUserBrowserComposites() ([]UserBrowserComposite, error) {
	var users []User
	var composites []UserBrowserComposite

	// 获取所有激活用户
	if err := DB.Where("active = ?", true).Find(&users).Error; err != nil {
		return nil, err
	}

	// 为每个用户构建组合
	for _, user := range users {
		// 获取用户的分组
		var groups []Group
		if err := DB.Where("user_id = ? AND active = ?", user.ID, true).Find(&groups).Error; err != nil {
			continue
		}

		// 如果没有找到分组，跳过该用户
		if len(groups) == 0 {
			continue
		}

		// 提取所有分组ID
		var groupIDs []uuid.UUID
		for _, group := range groups {
			groupIDs = append(groupIDs, group.ID)
		}

		// 获取所有分组下的浏览器
		var browsers []Browser
		if err := DB.Where("group_id IN ? AND active = ?", groupIDs, true).Find(&browsers).Error; err != nil {
			continue
		}

		// 如果没有浏览器，跳过该用户
		if len(browsers) == 0 {
			continue
		}

		// 组装数据，确保不重复
		browserTypes := make([]string, 0)
		externalGroupIDs := make([]int, 0)
		groupNames := make([]string, 0)

		// 为避免重复，使用map记录已添加的信息
		typesMap := make(map[string]bool)
		groupIDMap := make(map[int]bool)
		groupNameMap := make(map[string]bool)

		for _, browser := range browsers {
			if !typesMap[browser.BrowserType] {
				browserTypes = append(browserTypes, browser.BrowserType)
				typesMap[browser.BrowserType] = true
			}

			// 查找浏览器所属的分组
			for _, group := range groups {
				if group.ID == browser.GroupID {
					if !groupIDMap[group.GroupID] {
						externalGroupIDs = append(externalGroupIDs, group.GroupID)
						groupIDMap[group.GroupID] = true
					}

					if !groupNameMap[group.GroupName] {
						groupNames = append(groupNames, group.GroupName)
						groupNameMap[group.GroupName] = true
					}
					break
				}
			}
		}

		composite := UserBrowserComposite{
			UserID:       user.ID,
			Username:     user.Username,
			BrowserTypes: browserTypes,
			GroupIDs:     externalGroupIDs,
			GroupNames:   groupNames,
			IsActive:     user.Active,
		}

		composites = append(composites, composite)
	}

	return composites, nil
}

// 根据类型查找用户浏览器
func FindUserBrowsersByType(userID uuid.UUID, browserType string) ([]Browser, error) {
	// 获取用户的分组
	var groups []Group
	if err := DB.Where("user_id = ? AND active = ?", userID, true).Find(&groups).Error; err != nil {
		return nil, err
	}

	// 如果没有找到分组，返回空
	if len(groups) == 0 {
		return []Browser{}, nil
	}

	// 提取所有分组ID
	var groupIDs []uuid.UUID
	for _, group := range groups {
		groupIDs = append(groupIDs, group.ID)
	}

	// 查找指定类型的浏览器
	var browsers []Browser
	if err := DB.Where("group_id IN ? AND browser_type = ? AND active = ?",
		groupIDs, browserType, true).Find(&browsers).Error; err != nil {
		return nil, err
	}

	return browsers, nil
}

// FindBrowsers 根据条件查询浏览器
func FindBrowsers(query map[string]interface{}) ([]Browser, error) {
	var browsers []Browser
	result := DB.Where(query).Find(&browsers)
	return browsers, result.Error
}

// UpdateBrowserStatus 更新浏览器状态
func UpdateBrowserStatus(browserID uuid.UUID, active bool) error {
	return DB.Model(&Browser{}).Where("id = ?", browserID).Update("active", active).Error
}

// BrowserInfoForProxyApplication 用于代理应用的浏览器信息
type BrowserInfoForProxyApplication struct {
	BrowserID         uuid.UUID         `json:"browserId"`
	BrowserName       string            `json:"browserName"`
	BrowserType       string            `json:"browserType"`
	ExternalBrowserID int               `json:"externalBrowserId"`
	UserID            uuid.UUID         `json:"userId"`
	Username          string            `json:"username"`
	GroupName         string            `json:"groupName"`
	CurrentProxy      map[string]string `json:"currentProxy,omitempty" gorm:"-"` // 修改: 存储当前代理 {proxyIP: "...", proxyPort: "...", proxyId: "..."}
}

// GetAllActiveBrowsersForProxyApplication 获取所有适合应用代理的浏览器信息
func GetAllActiveBrowsersForProxyApplication() ([]BrowserInfoForProxyApplication, error) {
	var results []BrowserInfoForProxyApplication

	// Step 1: 查询浏览器基本信息 (不变)
	err := DB.Table("browsers").
		Select(`browsers.id as browser_id, browsers.browser_name, browsers.browser_type,
		        browsers.external_browser_id, groups.user_id, users.username, groups.group_name`).
		Joins("join `groups` on browsers.group_id = groups.id").
		Joins("join `users` on groups.user_id = users.id").
		Where("users.active = ? AND groups.active = ? AND browsers.active = ? AND browsers.expiration_time > ? AND browsers.external_browser_id > ?",
			true, true, true, time.Now(), 0).
		Order("browsers.browser_type, users.username, browsers.browser_name").
		Scan(&results).Error

	if err != nil { /* ... error handling ... */
	}
	if len(results) == 0 { /* ... return empty ... */
	}
	log.Printf("Fetched %d browsers", len(results))

	browserIDs := make([]uuid.UUID, len(results))
	for i, r := range results {
		browserIDs[i] = r.BrowserID
	}

	// Step 2: 查询这些浏览器的所有应用历史，按时间降序
	var allApplications []ProxyApplication
	if err := DB.Where("browser_id IN ?", browserIDs).
		Order("created_at DESC"). // 按时间降序排序
		Find(&allApplications).Error; err != nil {
		log.Printf("Warning: Error fetching proxy applications history: %v", err)
		// 即使历史查询失败，也继续返回浏览器列表，只是没有当前代理信息
	} else {
		log.Printf("Fetched %d total proxy application records for %d browsers", len(allApplications), len(results))
	}

	// Step 3: 筛选出每个浏览器的最新成功应用记录，并收集对应的 ProxyID
	latestSuccessfulApps := make(map[uuid.UUID]ProxyApplication) // browserID -> latest successful app
	neededProxyIDs := make(map[uuid.UUID]bool)

	// 遍历按时间排序后的所有记录
	for _, app := range allApplications {
		// 如果这个浏览器还没有记录最新的成功应用，并且当前记录是成功的
		if _, found := latestSuccessfulApps[app.BrowserID]; !found && app.Success && app.ProxyID != uuid.Nil {
			latestSuccessfulApps[app.BrowserID] = app
			neededProxyIDs[app.ProxyID] = true
		}
		// 由于已按时间降序，找到第一个成功的就跳过该浏览器后续更旧的记录
	}
	log.Printf("Found latest successful applications for %d browsers", len(latestSuccessfulApps))

	// Step 4: 查询需要的代理信息
	proxyMap := make(map[uuid.UUID]Proxy)
	if len(neededProxyIDs) > 0 {
		proxyIDsList := make([]uuid.UUID, 0, len(neededProxyIDs))
		for pid := range neededProxyIDs {
			proxyIDsList = append(proxyIDsList, pid)
		}

		var proxies []Proxy
		if err := DB.Where("id IN ?", proxyIDsList).Find(&proxies).Error; err != nil {
			log.Printf("Warning: Error fetching proxy details for history: %v", err)
		} else {
			for _, p := range proxies {
				proxyMap[p.ID] = p
			}
			log.Printf("Fetched details for %d required proxies", len(proxyMap))
		}
	}

	// Step 5: 将当前代理信息附加到结果中
	for i := range results {
		if app, foundApp := latestSuccessfulApps[results[i].BrowserID]; foundApp {
			if proxy, foundProxy := proxyMap[app.ProxyID]; foundProxy {
				results[i].CurrentProxy = map[string]string{
					"proxyIP":   proxy.ProxyIP,
					"proxyPort": proxy.ProxyPort,
					"proxyId":   proxy.ID.String(),
				}
			} else {
				log.Printf("Warning: Proxy details not found for ProxyID %s (BrowserID %s's latest successful app)", app.ProxyID, results[i].BrowserID)
			}
		}
		// 如果浏览器没有成功的应用记录，results[i].CurrentProxy 会保持 nil (即 JSON 中的 omitempty 生效)
	}

	return results, nil
}

// PhysicallyDeleteUser 从数据库中物理删除用户及其所有关联的分组和浏览器
func PhysicallyDeleteUser(id uuid.UUID) error {
	// 开始事务
	tx := DB.Begin()
	if tx.Error != nil {
		return tx.Error
	}

	// 延迟提交或回滚
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 先获取用户的所有分组
	var groups []Group
	if err := tx.Find(&groups, "user_id = ?", id).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 提取所有分组ID
	var groupIDs []uuid.UUID
	for _, group := range groups {
		groupIDs = append(groupIDs, group.ID)
	}

	// 物理删除所有分组下的浏览器
	if len(groupIDs) > 0 {
		if err := tx.Unscoped().Where("group_id IN ?", groupIDs).Delete(&Browser{}).Error; err != nil {
			tx.Rollback()
			return err
		}
	}

	// 物理删除所有分组
	if err := tx.Unscoped().Where("user_id = ?", id).Delete(&Group{}).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 物理删除用户
	if err := tx.Unscoped().Where("id = ?", id).Delete(&User{}).Error; err != nil {
		tx.Rollback()
		return err
	}
	// 物理删除用户对应的代理信息
	if err := tx.Unscoped().Where("user_id = ?", id).Delete(&ProxyApplication{}).Error; err != nil {
		tx.Rollback()
		return err
	}

	// 提交事务
	return tx.Commit().Error
}

// GetBrowsersByUsername 根据用户名（邮箱）查询其所有浏览器的指定信息 (支持分页)
func GetBrowsersByUsername(username string, page, size int) ([]CarBrowserInfo, int64, error) {
	var user User
	// 1. 根据用户名查找用户 (只查找活跃用户)
	if err := DB.Where("username = ? AND active = ?", username, true).First(&user).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, 0, fmt.Errorf("用户 '%s' 未找到或未激活", username)
		}
		log.Printf("Error finding user by username '%s': %v", username, err)
		return nil, 0, fmt.Errorf("查找用户时出错")
	}
	log.Printf("Found user: %s (ID: %s)", user.Username, user.ID)

	// 2. 查找该用户的所有活跃分组
	var groups []Group
	if err := DB.Where("user_id = ? AND active = ?", user.ID, true).Find(&groups).Error; err != nil {
		log.Printf("Error finding groups for user ID '%s': %v", user.ID, err)
		return nil, 0, fmt.Errorf("查找用户分组时出错")
	}

	// 如果没有分组，直接返回空列表
	if len(groups) == 0 {
		log.Printf("User ID '%s' has no active groups.", user.ID)
		return []CarBrowserInfo{}, 0, nil
	}

	// 提取所有分组ID
	var groupIDs []uuid.UUID
	for _, group := range groups {
		groupIDs = append(groupIDs, group.ID)
	}
	log.Printf("Found %d active groups for user ID '%s'", len(groups), user.ID)

	// 3. 查询这些分组下的所有浏览器 (无论浏览器是否 active) - 先计算总数
	var total int64
	countQuery := DB.Model(&Browser{}).Where("group_id IN ?", groupIDs)
	if err := countQuery.Count(&total).Error; err != nil {
		log.Printf("Error counting browsers for group IDs: %v", err)
		return nil, 0, fmt.Errorf("统计浏览器数量时出错")
	}
	log.Printf("Found total %d browsers associated with the groups.", total)

	// 如果总数为0，直接返回
	if total == 0 {
		return []CarBrowserInfo{}, 0, nil
	}

	// 4. 查询分页后的浏览器数据
	var browsers []Browser
	offset := (page - 1) * size
	if err := DB.Where("group_id IN ?", groupIDs).
		Order("created_at DESC"). // 或根据需要排序
		Offset(offset).
		Limit(size).
		Find(&browsers).Error; err != nil {
		log.Printf("Error finding browsers for group IDs (paginated): %v", err)
		return nil, 0, fmt.Errorf("查找浏览器信息时出错")
	}
	log.Printf("Fetched %d browsers for page %d, size %d.", len(browsers), page, size)

	// 5. 组装结果
	carInfos := make([]CarBrowserInfo, 0, len(browsers))
	for _, b := range browsers {
		// isPlus 逻辑: 目前没有明确逻辑，默认设为 0
		isPlusValue := 0
		// status 逻辑: 默认设为 1
		statusValue := 1

		carInfos = append(carInfos, CarBrowserInfo{
			CarID:           strconv.Itoa(b.ExternalBrowserID), // 将 int 转为 string
			BrowserName:     b.BrowserName,
			BrowserType:     b.BrowserType,
			BrowserTargName: b.BrowserTargName,
			ExpirationTime:  b.ExpirationTime,
			IsPlus:          isPlusValue,
			Status:          statusValue,
		})
	}

	return carInfos, total, nil
}
